// 版权归Go作者所有。版权所有。
// 此源代码的使用受BSD样式的约束
// 可以在许可证文件中找到的许可证。

package ssa

import (
	"cmd/compile/internal/types"
	"cmd/internal/src"
	"fmt"
	"sort"
)

// cse对函数执行公共子表达式消除。
// 值只是重新链接，不删除任何内容。后继死码
// 实际删除重复的表达式需要pass。
func cse(f *Func) {
	// 如果两个值满足以下定义，则它们是等效的：
	// 当量（v，w）：
	// v、 op==w.op
	// v、 类型==w.type
	// v、 aux==w.aux
	// v、 生长素==w.生长素
	// len（v.args）=len（w.args）
	// v、 block==w.block如果v.op==OpPhi
	// 0..len（v.args）-1中i的等效值（v.args[i]，w.args[i]）

	// 该算法搜索f值的一个分区
	// 使用上述定义的等价类。
	// 它从一个粗略的分区开始，然后迭代地细化它
	// 直到它到达一个固定点。

	// 使用上述条件的子集进行初始粗略划分。
	a := make([]*Value, 0, f.NumValues())
	if f.auxmap == nil {
		f.auxmap = auxmap{}
	}
	for _, b := range f.Blocks {
		for _, v := range b.Values {
			if v.Type.IsMemory() {
				continue // 内存值永远无法使用cse
			}
			if f.auxmap[v.Aux] == 0 {
				f.auxmap[v.Aux] = int32(len(f.auxmap)) + 1
			}
			a = append(a, v)
		}
	}
	partition := partitionValues(a, f.auxmap)

	// 从值id映射回eqclass id
	valueEqClass := make([]ID, f.NumValues())
	for _, b := range f.Blocks {
		for _, v := range b.Values {
			// 对唯一值使用负等价类。
			valueEqClass[v.ID] = -v.ID
		}
	}
	var pNum ID = 1
	for _, e := range partition {
		if f.pass.debug > 1 && len(e) > 500 {
			fmt.Printf("CSE.large partition (%d): ", len(e))
			for j := 0; j < 3; j++ {
				fmt.Printf("%s ", e[j].LongString())
			}
			fmt.Println()
		}

		for _, v := range e {
			valueEqClass[v.ID] = pNum
		}
		if f.pass.debug > 2 && len(e) > 1 {
			fmt.Printf("CSE.partition #%d:", pNum)
			for _, v := range e {
				fmt.Printf(" %s", v.String())
			}
			fmt.Printf("\n")
		}
		pNum++
	}

	// 在等价类存在的位置拆分等价类
	// 非等价参数。重复，直到我们找不到为止
	// 更多的分裂。
	var splitPoints []int
	byArgClass := new(partitionByArgClass) // 可重用的partitionByArgClass可减少分配
	for {
		changed := false

		// 分区可以在循环中增长。在这里不使用范围循环，
		// 我们在新添加的内容到达时处理它们，避免O（n^2）行为。
		for i := 0; i < len(partition); i++ {
			e := partition[i]

			if opcodeTable[e[0].Op].commutative {
				// 在比较之前，先对前两个参数进行排序。
				for _, v := range e {
					if valueEqClass[v.Args[0].ID] > valueEqClass[v.Args[1].ID] {
						v.Args[0], v.Args[1] = v.Args[1], v.Args[0]
					}
				}
			}

			// 按eq参数类排序。
			byArgClass.a = e
			byArgClass.eqClass = valueEqClass
			sort.Sort(byArgClass)

			// 找到分割点。
			splitPoints = append(splitPoints[:0], 0)
			for j := 1; j < len(e); j++ {
				v, w := e[j-1], e[j]
				// 注意：可交换参数已由byArgClass正确排序。
				eqArgs := true
				for k, a := range v.Args {
					b := w.Args[k]
					if valueEqClass[a.ID] != valueEqClass[b.ID] {
						eqArgs = false
						break
					}
				}
				if !eqArgs {
					splitPoints = append(splitPoints, j)
				}
			}
			if len(splitPoints) == 1 {
				continue // 不要拆分，不要使用等价类。
			}

			// 向下移动另一个等价类来代替e。
			partition[i] = partition[len(partition)-1]
			partition = partition[:len(partition)-1]
			i--

			// 为我们发现的e部分添加新的等价类。
			splitPoints = append(splitPoints, len(e))
			for j := 0; j < len(splitPoints)-1; j++ {
				f := e[splitPoints[j]:splitPoints[j+1]]
				if len(f) == 1 {
					// 不要添加单件。
					valueEqClass[f[0].ID] = -f[0].ID
					continue
				}
				for _, v := range f {
					valueEqClass[v.ID] = pNum
				}
				pNum++
				partition = append(partition, f)
			}
			changed = true
		}

		if !changed {
			break
		}
	}

	sdom := f.Sdom()

	// 计算我们想要做的替换。我们用v代替w
	// 如果v和w在同一等价类中，并且v支配w。
	rewrite := make([]*Value, f.NumValues())
	byDom := new(partitionByDom) // 可重用partitionByDom以减少allocs
	for _, e := range partition {
		byDom.a = e
		byDom.sdom = sdom
		sort.Sort(byDom)
		for i := 0; i < len(e)-1; i++ {
			// e按domorder排序，因此切片中的第一个元素是最大主导元素
			v := e[i]
			if v == nil {
				continue
			}

			e[i] = nil
			// 替换以v为主的e的所有元素
			for j := i + 1; j < len(e); j++ {
				w := e[j]
				if w == nil {
					continue
				}
				if sdom.IsAncestorEq(v.Block, w.Block) {
					rewrite[w.ID] = v
					e[j] = nil
				} else {
					// e是按domorder排序的，所以v.Block不会支配e中的任何后续块
					break
				}
			}
		}
	}

	rewrites := int64(0)

	// 应用替换
	for _, b := range f.Blocks {
		for _, v := range b.Values {
			for i, w := range v.Args {
				if x := rewrite[w.ID]; x != nil {
					if w.Pos.IsStmt() == src.PosIsStmt {
						// 即将丢失一个语句标记，w
						// w是v的输入；如果他们在同一个街区
						// 同一行，v是一个足够好的新语句边界。
						if w.Block == v.Block && w.Pos.Line() == v.Pos.Line() {
							v.Pos = v.Pos.WithIsStmt()
							w.Pos = w.Pos.WithNotStmt()
						} // TODO如果失败了呢？
					}
					v.SetArg(i, x)
					rewrites++
				}
			}
		}
		for i, v := range b.ControlValues() {
			if x := rewrite[v.ID]; x != nil {
				if v.Op == OpNilCheck {
					// nilcheck pass将删除nil检查和日志
					// 适当地使用它们，所以不要在这里与它们为伍。
					continue
				}
				b.ReplaceControl(i, x)
			}
		}
	}

	if f.pass.stats > 0 {
		f.LogStat("CSE REWRITES", rewrites)
	}
}

// eqclass近似于等价类。在
// 算法它可以表示多个
// 最终等价类。
type eqclass []*Value

// partitionValues将值划分为等价类
// 基于以下所有功能的匹配：
// -操作码
// -类型
// -生长素
// -辅助
// -纳格斯
// -块#如果是phi op
// -前两个arg操作码和生长素
// -不是前两个arg的aux；这可能会破坏CSE。
// partitionValues返回等价类的列表，每个
// 是按ID排序的*值列表。eqclass切片是
// 由与输入片相同的存储支持。
// 忽略大小为1的等价类。
func partitionValues(a []*Value, auxIDs auxmap) []eqclass {
	sort.Sort(sortvalues{a, auxIDs})

	var partition []eqclass
	for len(a) > 0 {
		v := a[0]
		j := 1
		for ; j < len(a); j++ {
			w := a[j]
			if cmpVal(v, w, auxIDs) != types.CMPeq {
				break
			}
		}
		if j > 1 {
			partition = append(partition, a[:j])
		}
		a = a[j:]
	}

	return partition
}
func lt2Cmp(isLt bool) types.Cmp {
	if isLt {
		return types.CMPlt
	}
	return types.CMPgt
}

type auxmap map[Aux]int32

func cmpVal(v, w *Value, auxIDs auxmap) types.Cmp {
	// 试着按成本对比订购（先便宜一点）
	if v.Op != w.Op {
		return lt2Cmp(v.Op < w.Op)
	}
	if v.AuxInt != w.AuxInt {
		return lt2Cmp(v.AuxInt < w.AuxInt)
	}
	if len(v.Args) != len(w.Args) {
		return lt2Cmp(len(v.Args) < len(w.Args))
	}
	if v.Op == OpPhi && v.Block != w.Block {
		return lt2Cmp(v.Block.ID < w.Block.ID)
	}
	if v.Type.IsMemory() {
		// 我们将永远无法实现两个价值观
		// 这会产生记忆。
		return lt2Cmp(v.ID < w.ID)
	}
	// OpSelect是一个伪操作。我们需要更积极一些
	// 关于CSE保持多个OpSelect相同
	// 现有的论点。
	if v.Op != OpSelect0 && v.Op != OpSelect1 && v.Op != OpSelectN {
		if tc := v.Type.Compare(w.Type); tc != types.CMPeq {
			return tc
		}
	}

	if v.Aux != w.Aux {
		if v.Aux == nil {
			return types.CMPlt
		}
		if w.Aux == nil {
			return types.CMPgt
		}
		return lt2Cmp(auxIDs[v.Aux] < auxIDs[w.Aux])
	}

	return types.CMPeq
}

// 对值进行排序以生成初始分区。
type sortvalues struct {
	a      []*Value // 值数组
	auxIDs auxmap   // 辅助->辅助ID映射
}

func (sv sortvalues) Len() int      { return len(sv.a) }
func (sv sortvalues) Swap(i, j int) { sv.a[i], sv.a[j] = sv.a[j], sv.a[i] }
func (sv sortvalues) Less(i, j int) bool {
	v := sv.a[i]
	w := sv.a[j]
	if cmp := cmpVal(v, w, sv.auxIDs); cmp != types.CMPeq {
		return cmp == types.CMPlt
	}

	// 最后按值ID排序以保持排序结果的确定性。
	return v.ID < w.ID
}

type partitionByDom struct {
	a    []*Value // 值数组
	sdom SparseTree
}

func (sv partitionByDom) Len() int      { return len(sv.a) }
func (sv partitionByDom) Swap(i, j int) { sv.a[i], sv.a[j] = sv.a[j], sv.a[i] }
func (sv partitionByDom) Less(i, j int) bool {
	v := sv.a[i]
	w := sv.a[j]
	return sv.sdom.domorder(v.Block) < sv.sdom.domorder(w.Block)
}

type partitionByArgClass struct {
	a       []*Value // 值数组
	eqClass []ID     // 值的等价类ID
}

func (sv partitionByArgClass) Len() int      { return len(sv.a) }
func (sv partitionByArgClass) Swap(i, j int) { sv.a[i], sv.a[j] = sv.a[j], sv.a[i] }
func (sv partitionByArgClass) Less(i, j int) bool {
	v := sv.a[i]
	w := sv.a[j]
	for i, a := range v.Args {
		b := w.Args[i]
		if sv.eqClass[a.ID] < sv.eqClass[b.ID] {
			return true
		}
		if sv.eqClass[a.ID] > sv.eqClass[b.ID] {
			return false
		}
	}
	return false
}
